Declarations of variables
Range of types
wC provides a wide range of types:
wint An integer
wshort An integer, possibly of reduced range
wlong An integer, possibly of increased range
wunsigned An integer with no negative range, the spare capacity being used to increase the positive range
wunsigned long Like unsigned, possibly of increased range
wdouble A double precision floating point number
wfloat A floating point (real) number
wchar A single byte of memory, enough to hold a character
w
In C, a variable must be declared before it can be used. Variables can be declared at the start of an block of code, but most are found at the start of each function. Most local variables appear when the function is called, and are destroyed on return from that function.
A declaration begins with the type, followed by the name of one or more variables.
Declarations can also be spread out. This allows space for an explanatory comment to be added. Variables can also be initialised when they are declared, this is done by adding an equals sign and the required value after the declaration.
int high = 250;
Variable high is declared as integer and is initialised to 250.
All of the integer types plus the char are called the integral types. float and double are called the real types.
Every variable has a name and a value. The name is used to identify the variable, the value is used to store data. There is a limitation on what these names can be. Every variable name in C must start with a letter, the rest of the name can consist of letters, numbers and underscore characters. C recognises upper and lower case characters as being different. Finally, you cannot use any of C's keywords like main, while, switch etc as variable names.
It is conventional to avoid the use of capital letters in variable names. These are used for names of constants. Some old implementations of C only use the first 8 characters of a variable name. Most modern ones don't apply this limit though.
The rules governing variable names also apply to the names of functions. We shall meet functions later on in the course.
For reasons not explained here, variables can only store finite numbers. Suppose that the size of a particular data type, that we'll call a gorb, is 1 byte. That means that gorbs can only represent 28*1 = 28 = 256 distinct values. So, gorbs might be able to store only the numbers between 0 and 255 (inclusive). Any number that you tried to store in a gorb which was smaller than 0, or larger than 255, would not be stored correctly; it would be stored as one of the values between 0 and 255. However, maybe you want to be able to store positive and negative numbers in gorbs, in which case you'd only be able to store 128 negative numbers and 128 positive numbers. Since we need to be able to store 0 also, you might decide that the range of values for a gorb is -128 to 127.
We've already learned about two different data types. What are the sizes of these data types, and what are the limits on the kinds of values that they can store? We just saw that a data type whose size is 1 byte can store 256 distinct values. Data types of size 2 bytes can store 28*2 = 216 = 65536 different values. Using the same formula, we determine that data types of size 4 bytes can store 28*4 = 232 = 4,294,967,296.
Unfortunately, the size of data types like int and float are not standard across all systems. The size of an int depends on your operating system and your hardware. Here are some typical values for ints and floats, along with some other important data types.
type     --    typical size   --   description
short      --     2 bytes   --   stores a short (i.e., small) integer
int      --     4 bytes   --   stores an integer
long      --     4 bytes   --   stores a long (i.e., large) integer
float      --     4 bytes   --   stores a floating-point number
double    --     8 bytes   --   stores a "double-precision" floating-point number